 \subsection{Données Géographiques}
 \subsubsection{Pré-requis}
 Les données géographique sont stockées sur une base de données PostgreSQL avant son extension PostGIS pour les données géographique, pour l'import des données il faut donc : 
 	\begin{itemize}
 		\item un SGBD, ici Postgres
 		\item une base de données PostGIS
 	\end{itemize}
 %conversion osm -> osm2psql
 \subsubsection{Import des données depuis OpenStreetMap}
 Pour importer les données depuis OpenStreetMap nous avons utilisé le programme osm2pgsql :
	\begin{verbatim}	
		osm2pgsql -s -U [user] -W -d [database] --host localhost --port 5432 --style default.style map.osm
	\end{verbatim}

Ce premier import génère 7 tables, mais ici nous allons nous intéresser plus particulièrement à 4 d'entre elles : 
\begin{itemize}
	\item planet\_osm\_line et planet\_osm\_roads :
		\begin{itemize}
			\item[] ces tables décrivent tous les objets représenté par des lignes : routes, chemins, ligne électrique, piste cyclable, ligne de tram, etc. Ici nous nous sommes uniquement intéressé au routes et chemins
		\end{itemize}
	\item planet\_osm\_polygon
		\begin{itemize}
			\item[] ces tables décrivent toutes les zones et bâtiments , par exemple zone commerciales, résidentielles, bâtiments
		\end{itemize}
	\item planet\_osm\_point
		\begin{itemize}
			\item[] ces tables décrivent tous les points d'intérêt : parking, arrêt de bus/tram, etc
		\end{itemize}
\end{itemize}
 %rendre les routes routables via osm2po4pgr
 \subsubsection{Modification des données }
 Pour pouvoir générer un graphe à partir des données présente dans la base il nous faut modifié les données.
 En effet chaque routes ne s'arrête pas à l'intersection avec une autre route. Or pour avoir un graphe correct il faut découper une route à chacune de ses intersection avec d'autre routes.

 Pour cela on utilise le programme JAVA osm2po4pgr qui rend les données brute de la base routable.

 Voici ce qui ce passe concrètement : \\
 \begin{figure}[h!]

    \parbox{.5\textwidth}{
        \includegraphics[scale=0.43]{images/before_osm2po.png}}
    \parbox{.4\textwidth}{
        \includegraphics[scale=0.5]{images/after_osm2po.png}}
    \caption{représentation des traitements effectué par osm\_2po\_4pgr}
 \end{figure}
 
 L'exécution d'osm\_2po\_4pgr génère une nouvelle table dans la base de donnée, celle ci contient l'identifiant de la route originale, et l'identifiant unique généré à chaque découpage de route.

\newpage

 %requête postgis pour intersection avec batiment
 \subsubsection{Requête post-gis pour les intersections}
 \paragraph*{intersections entre routes :}
 	Le découpage des routes expliqué précédemment, ne donne pas les intersections entre 2 routes différentes.
 	Pour avoir ces intersections, il faut faire une requête SQL : 
 	\begin{verbatimtab}[3]
 		SELECT distinct r.osm_id as id1 ,r2.osm_id as id2 
		FROM (
				SELECT osm_target_id as osm_id, geom_way as way
				FROM osm_2po_4pgr
			 )r,
			 (
				SELECT osm_target_id as osm_id, geom_way as way
				FROM osm_2po_4pgr
			 ) r2 
		WHERE 
			ST_INTERSECTS(r.way,r2.way) 
			and r.osm_id!=r2.osm_id;
 	\end{verbatimtab}
 	le traitement principal se fait via la fonction ST\_Intersects qui renvoie vrai si les deux géométries son en contact.

 \paragraph*{Intersection entre route et batiment :}
 	Les intersections entre routes et bâtiments pose plus de problème, en effet certains bâtiment ne touche aucune route, il faut donc calculer les intersections entre les routes et un buffer sur les polygones représentant les bâtiments.

 	La requête sql est la suivante : 
 	\begin{verbatimtab}[3]
 		SELECT distinct p.osm_id as id1, l.osm_target_id as id2_target, l.osm_source_id as id2_source, 
			st_astext( 
						ST_Intersection(
							st_transform(l.way,4326),
							ST_Buffer(st_transform(p.way,4326),0.0005)
						)
			) as intersections 
		FROM 
			( 
				SELECT osm_target_id as osm_target_id,osm_source_id as osm_source_id, geom_way as way 
				FROM osm_2po_4pgr o  
			) l,  
			(
				SELECT osm_id, way 
				FROM planet_osm_polygon 
				WHERE 
				building IS NOT NULL OR 
				( landuse IS NOT NULL 
					AND landuse <> 'residential' 
					AND landuse <> 'commercial' 
				) 
			) p 
		WHERE 
			ST_Intersects( 
				ST_Buffer(st_transform(p.way,4326),0.0005),st_transform(l.way,4326) 
			) 
		ORDER BY p.osm_id ASC , l.osm_target_id ;
 	\end{verbatimtab}

\newpage
 %recuperation des donnes via application jdbc
 \subsubsection{Récupération des données en JAVA}
 	Afin de récupérer les données pour générer le fichier map (au format XML), c'est ce fichier qui va être utilisé par l'application Android.

 	Ce programme utilise un driver JDBC pour :
 	\begin{itemize}
 		\item récupérer les données des requêtes SQL
 		\item définir les données supplémentaires comme le type de route/bâtiment
 		\item transformer les géométries au format WKT en objet java
 		\item éclate les routes en une liste de segments
 	\end{itemize}

 \subsubsection{Le fichier map}
 Le fichier map contient toutes les informations utiles pour l'affichage et le calcul d'itinéraire dans l'application Android.

 Chaque élément est défini comme suit : 
 \begin{itemize}
 	\item les polygones contiennent :
 		\begin{itemize}
 			\item un id
 			\item un type 
 			\item la liste de leurs points
 			\item la liste des segments intersectant le buffer du polygone 
 		\end{itemize}
 	\item les segments contiennent : 
 		\begin{itemize}
 			\item un id 
 			\item un type 
 			\item leurs 2 points
 			\item la liste des bâtiments avec lesquels ce segment est proche
 			\item la liste des segments touchant le segments 
 		\end{itemize}
 \end{itemize}